package org.fireking.myapplication

import android.graphics.Color
import android.view.MotionEvent
import com.github.mikephil.charting.charts.LineChart

/**
 * 图表绘图管理器，负责处理用户绘图操作并与Renderer交互
 */
class ChartDrawingManager(private val chart: LineChart) {

    // 当前绘制模式
    var drawingMode: DrawingMode = DrawingMode.NONE
        set(value) {
            field = value
            isDrawing = false
            drawingPoints.clear()

            // 如果不是编辑模式，切换绘制模式时退出编辑模式
            if (value != DrawingMode.EDIT) {
                drawingRenderer.setEditMode(false)
            } else {
                drawingRenderer.setEditMode(true)
            }
        }

    // 当前绘制的颜色
    var drawingColor: Int = Color.BLUE

    // 当前绘制的线宽
    var lineWidth: Float = 3f

    // 自定义绘图渲染器
    private val drawingRenderer = ChartDrawingRenderer(
        chart, chart.animator, chart.viewPortHandler
    )

    // 绘制中的标志
    private var isDrawing = false

    // 当前绘制的点集合
    private val drawingPoints = mutableListOf<Pair<Float, Float>>()

    init {
        // 设置自定义渲染器
        chart.renderer = drawingRenderer
    }

    /**
     * 清除所有绘制的图形
     */
    fun clearDrawings() {
        drawingRenderer.clearDrawings()
    }

    /**
     * 撤销上一步绘制
     */
    fun undo() {
        drawingRenderer.undo()
    }

    /**
     * 是否处于编辑模式
     */
    fun isInEditMode(): Boolean {
        return drawingRenderer.isInEditMode()
    }

    /**
     * 处理编辑模式下的触摸事件
     */
    fun handleEditModeTouch(x: Float, y: Float, action: Int): Boolean {
        return drawingRenderer.handleEditModeTouch(x, y, action)
    }

    /**
     * 处理触摸事件
     * @return 如果处理了触摸事件返回true，否则返回false让图表处理
     */
    fun onTouchEvent(event: MotionEvent): Boolean {
        // 如果处于编辑模式，则不处理正常的绘图操作
        if (drawingMode == DrawingMode.EDIT) {
            return false
        }

        if (drawingMode == DrawingMode.NONE) {
            return false // 不拦截事件，让图表处理
        }

        val x = event.x
        val y = event.y

        when (event.action) {
            MotionEvent.ACTION_DOWN -> {
                isDrawing = true
                drawingPoints.clear()
                drawingPoints.add(Pair(x, y))
                return true
            }

            MotionEvent.ACTION_MOVE -> {
                if (isDrawing) {
                    when (drawingMode) {
                        DrawingMode.LINE -> {
                            if (drawingPoints.size > 1) {
                                drawingPoints[1] = Pair(x, y)
                            } else {
                                drawingPoints.add(Pair(x, y))
                            }
                            // 不需要刷新图表，因为这是预览
                        }

                        DrawingMode.RECTANGLE -> {
                            if (drawingPoints.size > 1) {
                                drawingPoints[1] = Pair(x, y)
                            } else {
                                drawingPoints.add(Pair(x, y))
                            }
                            // 不需要刷新图表，因为这是预览
                        }

                        DrawingMode.CURVE -> {
                            drawingPoints.add(Pair(x, y))
                            // 不需要刷新图表，因为这是预览
                        }

                        else -> { /* 不处理 */
                        }
                    }
                    return true
                }
            }

            MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
                if (isDrawing) {
                    when (drawingMode) {
                        DrawingMode.LINE -> {
                            if (drawingPoints.size >= 2) {
                                // 添加直线
                                val start = drawingPoints[0]
                                val end = drawingPoints[1]
                                drawingRenderer.addLine(
                                    start.first,
                                    start.second,
                                    end.first,
                                    end.second,
                                    drawingColor,
                                    lineWidth
                                )
                            }
                        }

                        DrawingMode.RECTANGLE -> {
                            if (drawingPoints.size >= 2) {
                                val p1 = drawingPoints[0]
                                val p2 = drawingPoints[1]
                                val left = minOf(p1.first, p2.first)
                                val top = minOf(p1.second, p2.second)
                                val right = maxOf(p1.first, p2.first)
                                val bottom = maxOf(p1.second, p2.second)

                                // 添加矩形
                                drawingRenderer.addRectangle(
                                    left, top, right, bottom, drawingColor, lineWidth
                                )
                            }
                        }

                        DrawingMode.CURVE -> {
                            if (drawingPoints.size >= 2) {
                                // 添加曲线
                                drawingRenderer.addCurve(
                                    drawingPoints.toMutableList(), drawingColor, lineWidth
                                )
                            }
                        }

                        else -> { /* 不处理 */
                        }
                    }

                    // 如果是直线、矩形或曲线，绘制完成后自动重置点
                    if (drawingMode == DrawingMode.LINE || drawingMode == DrawingMode.RECTANGLE || drawingMode == DrawingMode.CURVE) {
                        drawingPoints.clear()
                    }

                    isDrawing = false
                    return true
                }
            }
        }

        return false
    }

    /**
     * 将当前选中的图形移到顶层
     */
    fun bringSelectedShapeToFront() {
        drawingRenderer.bringSelectedShapeToFront()
    }

    /**
     * 将当前选中的图形移到底层
     */
    fun sendSelectedShapeToBack() {
        drawingRenderer.sendSelectedShapeToBack()
    }

    // 绘制模式枚举
    enum class DrawingMode {
        NONE,      // 不绘制
        LINE,      // 直线
        RECTANGLE, // 矩形
        CURVE,     // 曲线
        EDIT       // 编辑模式
    }
} 